package core;

import java.util.Set;

/**
 * Boolean类型相关工具类
 */
public class BooleanUtil {

    /**
     * 表示为真的字符串
     */
    private static final Set<String> TRUE_SET = Set.of("true", "yes", "y", "t", "ok", "1", "on", "是", "对", "真", "對", "√");
    /**
     * 表示为假的字符串
     */
    private static final Set<String> FALSE_SET = Set.of("false", "no", "n", "f", "0", "off", "否", "错", "假", "錯", "×");

    /**
     * 取相反值
     *
     * @param bool Boolean值
     * @return 相反的Boolean值
     */
    public static Boolean negate(Boolean bool) {
        if (bool == null) {
            return null;
        }
        return bool ? Boolean.FALSE : Boolean.TRUE;
    }

    /**
     * 检查 {@code Boolean} 值是否为 {@code true}
     *
     * @param bool 被检查的Boolean值
     * @return 当值为true且非null时返回{@code true}
     */
    public static boolean isTrue(Boolean bool) {
        return Boolean.TRUE.equals(bool);
    }

    /**
     * 检查 {@code Boolean} 值是否为 {@code false}
     *
     * @param bool 被检查的Boolean值
     * @return 当值为false且非null时返回{@code true}
     */
    public static boolean isFalse(Boolean bool) {
        return Boolean.FALSE.equals(bool);
    }

    /**
     * 转换为Boolean对象
     *
     * @param value 值
     * @return Boolean对象
     */
    public static Boolean toBooleanObject(boolean value) {
        return value ? Boolean.TRUE : Boolean.FALSE;
    }

    /**
     * 转换为Boolean对象
     *
     * @param value 值
     * @return Boolean对象，如果原始值为null，则返回null
     */
    public static Boolean toBooleanObject(Boolean value) {
        return value;
    }

    /**
     * 转换为Boolean对象
     *
     * @param value 值
     * @return Boolean对象，如果原始值为null，则返回null
     */
    public static Boolean toBooleanObject(String value) {
        if (value == null) {
            return null;
        }
        value = value.trim().toLowerCase();
        if (TRUE_SET.contains(value)) {
            return Boolean.TRUE;
        }
        if (FALSE_SET.contains(value)) {
            return Boolean.FALSE;
        }
        return null;
    }

    /**
     * 转换为boolean值
     *
     * @param value        值
     * @param defaultValue 默认值
     * @return boolean值
     */
    public static boolean toBoolean(String value, boolean defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        value = value.trim().toLowerCase();
        if (TRUE_SET.contains(value)) {
            return true;
        }
        if (FALSE_SET.contains(value)) {
            return false;
        }
        return defaultValue;
    }

    /**
     * 转换为boolean值
     *
     * @param value 值
     * @return boolean值
     */
    public static boolean toBoolean(Boolean value) {
        return toBoolean(value, false);
    }

    /**
     * 转换为boolean值
     *
     * @param value        值
     * @param defaultValue 默认值
     * @return boolean值
     */
    public static boolean toBoolean(Boolean value, boolean defaultValue) {
        return value == null ? defaultValue : value;
    }

    /**
     * 转换为boolean值
     *
     * @param value 值
     * @return boolean值
     */
    public static boolean toBoolean(String value) {
        return toBoolean(value, false);
    }

    /**
     * 转换为boolean值
     *
     * @param value 值
     * @return boolean值
     */
    public static boolean toBoolean(int value) {
        return value != 0;
    }

    /**
     * 转换为boolean值
     *
     * @param value        值
     * @param defaultValue 默认值
     * @return boolean值
     */
    public static boolean toBoolean(Integer value, boolean defaultValue) {
        return value == null ? defaultValue : value != 0;
    }

    /**
     * 转换为Boolean数组
     *
     * @param values 值
     * @return Boolean数组
     */
    public static Boolean[] toBooleanArray(boolean[] values) {
        if (values == null) {
            return null;
        }
        final Boolean[] result = new Boolean[values.length];
        for (int i = 0; i < values.length; i++) {
            result[i] = values[i];
        }
        return result;
    }

    /**
     * 转换为boolean数组
     *
     * @param values 值
     * @return boolean数组
     */
    public static boolean[] toPrimitiveArray(Boolean[] values) {
        if (values == null) {
            return null;
        }
        final boolean[] result = new boolean[values.length];
        for (int i = 0; i < values.length; i++) {
            result[i] = values[i];
        }
        return result;
    }

    /**
     * 比较两个布尔值
     *
     * @param b1 第一个布尔值
     * @param b2 第二个布尔值
     * @return 如果两个布尔值相等返回0，如果不相等，true大于false
     */
    public static int compare(boolean b1, boolean b2) {
        if (b1 == b2) {
            return 0;
        }
        return b1 ? 1 : -1;
    }

    /**
     * 安全的AND操作
     *
     * @param array 布尔值数组
     * @return AND操作结果
     */
    public static boolean and(boolean... array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("The Array must not be empty");
        }
        for (boolean element : array) {
            if (!element) {
                return false;
            }
        }
        return true;
    }

    /**
     * 安全的OR操作
     *
     * @param array 布尔值数组
     * @return OR操作结果
     */
    public static boolean or(boolean... array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("The Array must not be empty");
        }
        for (boolean element : array) {
            if (element) {
                return true;
            }
        }
        return false;
    }

    /**
     * 安全的XOR操作
     *
     * @param array 布尔值数组
     * @return XOR操作结果
     */
    public static boolean xor(boolean... array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("The Array must not be empty");
        }
        boolean result = false;
        for (boolean element : array) {
            result ^= element;
        }
        return result;
    }
}